home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / ibm / r3sim.arc / INSTR2.C < prev    next >
C/C++ Source or Header  |  1989-07-08  |  15KB  |  696 lines
  1. /******
  2.     Program: 68705R3 simulator
  3.     File: INSTR2.C
  4.     Notes: This file contiains the code for individual 6805 instructions.
  5.         It uses routines in INSTR.C
  6. ******/
  7.  
  8. #include "sim.h"
  9.  
  10. #ifdef MSC
  11. #include <graph.h>
  12. #endif
  13.  
  14. #define RW_A -1
  15. #define RW_X -2
  16. #define RW_SP -3
  17.  
  18. /************************************************************************/
  19. /* Routines to set condition code register bits for numeric op result   */
  20.  
  21. int ccr_c( value)
  22. int value;
  23. {
  24.     if (value < 0)
  25.     {
  26.     value += 256;
  27.     pgm_model.ccr |= CC_C;
  28.     }
  29.     else if (value > 255)
  30.     {
  31.     value -= 256;
  32.     pgm_model.ccr |= CC_C;
  33.     }
  34.     else
  35.     pgm_model.ccr &= ~CC_C;
  36.     return( value);
  37. }
  38.  
  39. int ccr_z( value)
  40. int value;
  41. {
  42.     if (value == 0)
  43.     pgm_model.ccr |= CC_Z;
  44.     else
  45.     pgm_model.ccr &= ~CC_Z;
  46.     return( value);
  47. }
  48.  
  49. int ccr_n( value)
  50. int value;
  51. {
  52.     if (value & 0x80)
  53.     pgm_model.ccr |= CC_N;
  54.     else
  55.     pgm_model.ccr &= ~CC_N;
  56.     return( value);
  57. }
  58. /************************************************************************/
  59. int std_ccr(value)
  60. int value;
  61. /* Set C, Z and N bits in ccr based on value */
  62. /* This is appropriate for SUB, CMP, SBC, CPX etc numeric instructions */
  63. {
  64.     value = ccr_c( value);
  65.     value = ccr_z( value);
  66.     value = ccr_n( value);
  67. }
  68. /************************************************************************/
  69.  
  70. sub( mode)
  71. int mode;
  72. {
  73.     int addr, data;
  74.  
  75.     addr = get_ea( mode);
  76.     data = sim_read( addr);
  77.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  78.     pgm_model.a -= data;
  79.     pgm_model.a = std_ccr( pgm_model.a);
  80.     append_rw( 0, RW_A, pgm_model.a);
  81. }
  82.  
  83. cmp( mode)
  84. int mode;
  85. {
  86.     int addr, data, result;
  87.  
  88.     addr = get_ea( mode);
  89.     data = sim_read( addr);
  90.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  91.     result = pgm_model.a - data;
  92.     result = std_ccr( result);
  93. }
  94.  
  95. sbc( mode)
  96. int mode;
  97. {
  98.     int addr, data;
  99.  
  100.     addr = get_ea( mode);
  101.     data = sim_read( addr);
  102.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  103.     pgm_model.a -= data;
  104.     if (pgm_model.ccr & CC_C)
  105.     pgm_model.a--;
  106.     pgm_model.a = std_ccr( pgm_model.a);
  107.     append_rw( 0, RW_A, pgm_model.a);
  108. }
  109.  
  110. cpx( mode)
  111. int mode;
  112. {
  113.     int addr, data, result;
  114.  
  115.     addr = get_ea( mode);
  116.     data = sim_read( addr);
  117.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  118.     result = pgm_model.x - data;
  119.     result = std_ccr( result);
  120. }
  121.  
  122. and( mode)
  123. int mode;
  124. {
  125.     int addr, data;
  126.  
  127.     addr = get_ea( mode);
  128.     data = sim_read( addr);
  129.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  130.     pgm_model.a &= data;
  131.     pgm_model.a = ccr_n( pgm_model.a);
  132.     pgm_model.a = ccr_z( pgm_model.a);
  133.     append_rw( 0, RW_A, pgm_model.a);
  134. }
  135.  
  136. bit( mode)
  137. int mode;
  138. {
  139.     int addr, data, result;
  140.  
  141.     addr = get_ea( mode);
  142.     data = sim_read( addr);
  143.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  144.     result = pgm_model.a & data;
  145.     result = ccr_n( result);
  146.     result = ccr_z( result);
  147. }
  148.  
  149. lda( mode)
  150. int mode;
  151. {
  152.     int addr, data;
  153.  
  154.     addr = get_ea( mode);
  155.     data = sim_read( addr);
  156.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  157.     pgm_model.a = data;
  158.     pgm_model.a = ccr_n( pgm_model.a);
  159.     pgm_model.a = ccr_z( pgm_model.a);
  160.     append_rw( 0, RW_A, pgm_model.a);
  161. }
  162.  
  163. sta( mode)
  164. int mode;
  165. /* Note: mode is never IMMEDIATE */
  166. {
  167.     int addr, data, temp;
  168.  
  169.     addr = get_ea( mode);
  170.     sim_write( addr, pgm_model.a);
  171.     append_rw( 0, addr, pgm_model.a);   /* 1 = Read, 0 = Write */
  172.     temp = ccr_n( pgm_model.a);
  173.     temp = ccr_z( pgm_model.a);
  174. }
  175.  
  176. eor( mode)
  177. int mode;
  178. {
  179.     int addr, data;
  180.  
  181.     addr = get_ea( mode);
  182.     data = sim_read( addr);
  183.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  184.     pgm_model.a ^= data;
  185.     pgm_model.a = ccr_n( pgm_model.a);
  186.     pgm_model.a = ccr_z( pgm_model.a);
  187.     append_rw( 0, RW_A, pgm_model.a);
  188. }
  189.  
  190. adc( mode)
  191. int mode;
  192. {
  193.     int addr, data, result;
  194.  
  195.     addr = get_ea( mode);
  196.     data = sim_read( addr);
  197.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  198.     result = pgm_model.a + data;
  199.     if (pgm_model.ccr & CC_C)
  200.     result++;
  201.     if (  ((pgm_model.a & 0x08) & (data & 0x08)) ||
  202.           ((data & 0x08) & (~result & 0x08)) ||
  203.           ((pgm_model.a & 0x08) & (~result & 0x08)) )
  204.     pgm_model.ccr |= CC_H;
  205.     else
  206.     pgm_model.ccr &= ~CC_H;
  207.     pgm_model.a = std_ccr( result);
  208.     append_rw( 0, RW_A, pgm_model.a);
  209. }
  210.  
  211. ora( mode)
  212. int mode;
  213. {
  214.     int addr, data;
  215.  
  216.     addr = get_ea( mode);
  217.     data = sim_read( addr);
  218.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  219.     pgm_model.a |= data;
  220.     pgm_model.a = ccr_n( pgm_model.a);
  221.     pgm_model.a = ccr_z( pgm_model.a);
  222.     append_rw( 0, RW_A, pgm_model.a);
  223. }
  224.  
  225. add( mode)
  226. int mode;
  227. {
  228.     int addr, data, result;
  229.  
  230.     addr = get_ea( mode);
  231.     data = sim_read( addr);
  232.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  233.     result = pgm_model.a + data;
  234.     if (  ((pgm_model.a & 0x08) & (data & 0x08)) ||
  235.           ((data & 0x08) & (~result & 0x08)) ||
  236.           ((pgm_model.a & 0x08) & (~result & 0x08)) )
  237.     pgm_model.ccr |= CC_H;
  238.     else
  239.     pgm_model.ccr &= ~CC_H;
  240.     pgm_model.a = std_ccr( result);
  241.     append_rw( 0, RW_A, pgm_model.a);
  242. }
  243.  
  244. jmp( mode)
  245. int mode;
  246. {
  247.     if (!disassemble)
  248.     pgm_model.pc = get_ea( mode);
  249.     /* condition codes are not affected */
  250. }
  251.  
  252. jsr( mode)
  253. int mode;
  254. {
  255.     int addr;
  256.  
  257.     addr = get_ea( mode);
  258.     if (!disassemble)
  259.     {
  260.     push( pgm_model.pc & 0xFF);    /* PCL */
  261.     push(((pgm_model.pc & 0xF00) >> 8) | 0xF000);      /* PCH */
  262.     pgm_model.pc = addr;
  263.     }
  264. }
  265.  
  266. bsr( mode)
  267. int mode;  /* Must be REL */
  268. {
  269.     jsr( mode);    /* identical to JSR except for address mode, */
  270.                    /* which is handled by get_ea() */
  271. }
  272.  
  273. ldx( mode)
  274. int mode;
  275. {
  276.     int addr, data;
  277.  
  278.     addr = get_ea( mode);
  279.     data = sim_read( addr);
  280.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  281.     pgm_model.x = data;
  282.     data = ccr_n( data);
  283.     data = ccr_z( data);
  284. }
  285.  
  286. stx( mode)
  287. {
  288.     int addr, data;
  289.  
  290.     addr = get_ea( mode);
  291.     sim_write( addr, pgm_model.x);
  292.     append_rw( 0, addr, pgm_model.x);   /* 1 = Read, 0 = Write */
  293.     data = pgm_model.x;
  294.     data = ccr_n( data);
  295.     data = ccr_z( data);
  296. }
  297.  
  298. bset( bit)
  299. int bit;
  300. {
  301.     int addr, data;
  302.  
  303.     addr = get_ea( DIRECT);
  304.     data = sim_bitread( addr, bit);  /* Returns byte value just like simread */
  305.                                      /* Bit is used to check bit in ports */
  306.                      /* See sim_mem.c */
  307.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  308.     data |= 1<<bit;
  309.     sim_write( addr, data);
  310.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  311. }
  312.  
  313. bclr( bit)
  314. int bit;
  315. {
  316.     int addr, data;
  317.  
  318.     addr = get_ea( DIRECT);
  319.     data = sim_bitread( addr, bit);   /* See note above */
  320.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  321.     data &= ~(1<<bit);
  322.     sim_write( addr, data);
  323.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  324. }
  325.  
  326. brset( bit)
  327. int bit;
  328. {
  329.     int addr, data;
  330.  
  331.     addr = get_ea( DIRECT);
  332.     data = sim_bitread( addr, bit);  /* Returns byte value just like simread */
  333.                                      /* Bit is used to check bit in ports */
  334.                      /* See sim_mem.c */
  335.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  336.     addr = get_ea( BTB);   /* Bit Test & Branch - branch rel */
  337.     if (data & (1 << bit))
  338.     {
  339.     if (!disassemble)
  340.         pgm_model.pc = addr;
  341.     pgm_model.ccr |= CC_C;
  342.     }
  343.     else
  344.     pgm_model.ccr &= ~CC_C;
  345. }
  346.  
  347. brclr( bit)
  348. int bit;
  349. {
  350.     int addr, data;
  351.  
  352.     addr = get_ea( DIRECT);
  353.     data = sim_bitread( addr, bit);       /* See note above */
  354.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  355.     addr = get_ea( BTB);   /* Bit Test & Branch - branch rel */
  356.     if (data & (1 << bit))
  357.     pgm_model.ccr |= CC_C;
  358.     else
  359.     {
  360.     if (!disassemble)
  361.         pgm_model.pc = addr;
  362.     pgm_model.ccr &= ~CC_C;
  363.     }
  364. }
  365.  
  366. branch( brtype)
  367. int brtype;
  368. {
  369.     int addr, brflag;
  370.  
  371.     addr = get_ea( REL);
  372.     switch (brtype)
  373.     {
  374.     case 0: /* BRA */
  375.     brflag = 1;
  376.     break;
  377.     case 1: /* BRN */
  378.     brflag = 0;
  379.     break;
  380.     case 2: /* BHI */
  381.     brflag= ((pgm_model.ccr & CC_C) == 0) && ((pgm_model.ccr & CC_Z) == 0);
  382.     break;
  383.     case 3: /* BLS */
  384.     brflag= ((pgm_model.ccr & CC_C) != 0) || ((pgm_model.ccr & CC_Z) != 0);
  385.     break;
  386.     case 4: /* BCC */
  387.     brflag = ((pgm_model.ccr & CC_C) == 0);
  388.     break;
  389.     case 5: /* BCS */
  390.     brflag = ((pgm_model.ccr & CC_C) != 0);
  391.     break;
  392.     case 6: /* BNE */
  393.     brflag = ((pgm_model.ccr & CC_Z) == 0);
  394.     break;
  395.     case 7: /* BEQ */
  396.     brflag = ((pgm_model.ccr & CC_Z) != 0);
  397.     break;
  398.     case 8: /* BHCC */
  399.     brflag = ((pgm_model.ccr & CC_H) == 0);
  400.     break;
  401.     case 9: /* BHCS */
  402.     brflag = ((pgm_model.ccr & CC_H) != 0);
  403.     break;
  404.     case 10: /* BPL */
  405.     brflag = ((pgm_model.ccr & CC_N) == 0);
  406.     break;
  407.     case 11: /* BMI */
  408.     brflag = ((pgm_model.ccr & CC_N) != 0);
  409.     break;
  410.     case 12: /* BMC */
  411.     brflag = ((pgm_model.ccr & CC_I) == 0);
  412.     break;
  413.     case 13: /* BMS */
  414.     brflag = ((pgm_model.ccr & CC_I) != 0);
  415.     break;
  416.     case 14: /* BIL */
  417.     brflag = external_intr;
  418.     break;
  419.     case 15: /* BIH */
  420.     brflag = !external_intr;
  421.     break;
  422.     default:
  423.     brflag = 0;
  424.     break;
  425.     }
  426.     if (brflag && !disassemble)
  427.     pgm_model.pc = addr;
  428. }
  429.  
  430. neg( mode)
  431. int mode;
  432. {
  433.     int addr, data;
  434.  
  435.     addr = get_ea( mode);
  436.     data = sim_read( addr);
  437.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  438.     data = 0 - data;
  439.     data = std_ccr( data);    /* will get value in 0-255 and set C, N, Z */
  440.     sim_write( addr, data);
  441.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  442. }
  443.  
  444. com( mode)
  445. int mode;
  446. {
  447.     int addr, data;
  448.  
  449.     addr = get_ea( mode);
  450.     data = sim_read( addr);
  451.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  452.     data ^= 0xFF;
  453.     data = ccr_n( data);
  454.     data = ccr_z( data);
  455.     pgm_model.ccr |= CC_C;      /* Carry always set */
  456.     sim_write( addr, data);
  457.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  458. }
  459.  
  460. lsr( mode)
  461. int mode;
  462. {
  463.     int addr, data;
  464.  
  465.     addr = get_ea( mode);
  466.     data = sim_read( addr);
  467.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  468.     if (data & 0x01)
  469.         pgm_model.ccr |= CC_C;
  470.     else
  471.     pgm_model.ccr &= ~CC_C;
  472.     data >>= 1;
  473.     data = ccr_n( data);     /* N will always be 0 */
  474.     data = ccr_z( data);
  475.     sim_write( addr, data);
  476.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  477. }
  478.  
  479. ror( mode)
  480. int mode;
  481. {
  482.     int addr, data, newdata;
  483.  
  484.     addr = get_ea( mode);
  485.     data = sim_read( addr);
  486.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  487.     newdata = data >>1;
  488.     if (pgm_model.ccr & CC_C)
  489.     newdata |= 0x80;
  490.     if (data & 0x01)
  491.         pgm_model.ccr |= CC_C;
  492.     else
  493.     pgm_model.ccr &= ~CC_C;
  494.     newdata = ccr_n( newdata);
  495.     newdata = ccr_z( newdata);
  496.     sim_write( addr, newdata);
  497.     append_rw( 0, addr, newdata);   /* 1 = Read, 0 = Write */
  498. }
  499.  
  500. asr( mode)
  501. int mode;
  502. {
  503.     int addr, data;
  504.  
  505.     addr = get_ea( mode);
  506.     data = sim_read( addr);
  507.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  508.     if (data & 0x01)
  509.         pgm_model.ccr |= CC_C;
  510.     else
  511.     pgm_model.ccr &= ~CC_C;
  512.     data >>= 1;
  513.     if (data & 0x40)
  514.     data |= 0x80;        /* hold bit 7 constant */
  515.     data = ccr_n( data);
  516.     data = ccr_z( data);
  517.     sim_write( addr, data);
  518.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  519. }
  520.  
  521. lsl( mode)
  522. int mode;
  523. {
  524.     int addr, data;
  525.  
  526.     addr = get_ea( mode);
  527.     data = sim_read( addr);
  528.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  529.     data <<= 1;
  530.     data = std_ccr( data);       /* if b7 was on, C will be set and data */
  531.                                  /* corrected by subtracting 256 - perfect! */ 
  532.     sim_write( addr, data);
  533.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  534. }
  535.  
  536. rol( mode)
  537. int mode;
  538. {
  539.     int addr, data, newdata;
  540.  
  541.     addr = get_ea( mode);
  542.     data = sim_read( addr);
  543.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  544.     newdata = data <<1;
  545.     if (pgm_model.ccr & CC_C)
  546.     newdata |= 0x01;
  547.     if (data & 0x80)
  548.         pgm_model.ccr |= CC_C;
  549.     else
  550.     pgm_model.ccr &= ~CC_C;
  551.     newdata = ccr_n( newdata);
  552.     newdata = ccr_z( newdata);
  553.     sim_write( addr, newdata);
  554.     append_rw( 0, addr, newdata);   /* 1 = Read, 0 = Write */
  555. }
  556.  
  557. dec( mode)
  558. int mode;
  559. {
  560.     int addr, data;
  561.  
  562.     addr = get_ea( mode);
  563.     data = sim_read( addr);
  564.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  565.     data -= 1;
  566.     if (data < 0)
  567.     data = 255;
  568.     data = ccr_n( data);
  569.     data = ccr_z( data);
  570.     sim_write( addr, data);
  571.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  572. }
  573.  
  574. inc( mode)
  575. int mode;
  576. {
  577.     int addr, data;
  578.  
  579.     addr = get_ea( mode);
  580.     data = sim_read( addr);
  581.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  582.     data += 1;
  583.     if (data >= 256)
  584.     data = 0;
  585.     data = ccr_n( data);
  586.     data = ccr_z( data);
  587.     sim_write( addr, data);
  588.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  589. }
  590.  
  591. tst( mode)
  592. int mode;
  593. {
  594.     int addr, data;
  595.  
  596.     addr = get_ea( mode);
  597.     data = sim_read( addr);
  598.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  599.     /* No operation on data, or, if you prefer data = data - 0 */
  600.     data = ccr_n( data);
  601.     data = ccr_z( data);
  602. }
  603.  
  604. clr( mode)
  605. int mode;
  606. {
  607.     int addr, data;
  608.  
  609.     addr = get_ea( mode);
  610.     data = sim_read( addr);
  611.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  612.     data = 0;
  613.     data = ccr_n( data);
  614.     data = ccr_z( data);
  615.     sim_write( addr, data);
  616.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  617. }
  618.  
  619. swi(mode)
  620. int mode;
  621. {
  622.     rinterrupt( 0xFFC);    /* in instr.c */
  623. }
  624.  
  625. rts(mode)
  626. int mode;
  627. {
  628.     if (!disassemble)
  629.     {
  630.     pgm_model.pc = (( pull() & 0x0F ) << 8);
  631.     pgm_model.pc +=  pull();
  632.     }
  633. }
  634.  
  635. rti(mode)
  636. int mode;
  637. {
  638.     pgm_model.ccr = pull() & 0x1F;
  639.     pgm_model.a = pull();
  640.     pgm_model.x = pull();
  641.     rts( mode);
  642. }
  643.  
  644. tax( mode)
  645. int mode;
  646. {
  647.     pgm_model.x = pgm_model.a;
  648.     append_rw( 0, RW_X, pgm_model.x);   /* 1 = Read, 0 = Write */
  649. }
  650.  
  651. txa( mode)
  652. int mode;
  653. {
  654.     pgm_model.a = pgm_model.x;
  655.     append_rw( 0, RW_A, pgm_model.a);   /* 1 = Read, 0 = Write */
  656. }
  657.  
  658. clc( mode)
  659. int mode;
  660. {
  661.     pgm_model.ccr &= ~CC_C;
  662. }
  663.  
  664. sec( mode)
  665. int mode;
  666. {
  667.     pgm_model.ccr |= CC_C;
  668. }
  669.  
  670. cli( mode)
  671. int mode;
  672. {
  673.     pgm_model.ccr &= ~CC_I;
  674. }
  675.  
  676. sei( mode)
  677. int mode;
  678. {
  679.     pgm_model.ccr |= CC_I;
  680. }
  681.  
  682. nop( mode)
  683. int mode;
  684. {
  685.     /* no operation */
  686.     return( mode);
  687. }
  688.  
  689. rsp( mode)
  690. int mode;
  691. {
  692.     pgm_model.sp = 0x7F;
  693. }
  694.  
  695. /**************** end of file instr2.c **********************************/
  696.